/**
 * 头像处理工具函数
 */

/**
 * 获取头像URL（本地处理版本）
 * @param {string|Object} avatarPath - 头像路径或医生信息对象
 * @param {number} gender - 性别 (1: 男, 2: 女)
 * @returns {string} 头像URL
 */
export const getAvatarUrl = (avatarPath, gender = null) => {
  // 处理参数格式
  let avatar = avatarPath
  let doctorGender = gender
  
  // 如果传入的是对象，提取avatar和gender
  if (typeof avatarPath === 'object' && avatarPath !== null) {
    avatar = avatarPath.avatar
    doctorGender = avatarPath.gender
  }
  
  // 添加调试信息
  console.log('getAvatarUrl 被调用，参数:', {
    avatar: avatar || 'null',
    gender: doctorGender
  })
  
  // 检查头像数据是否有效
  if (avatar && avatar !== 'null' && avatar !== 'undefined') {
    // 如果已经是完整的URL，直接返回
    if (avatar.startsWith('http://') || avatar.startsWith('https://')) {
      return avatar
    }
    
    // 如果是相对路径（以/开头），直接返回
    if (avatar.startsWith('/')) {
      return avatar
    }
    
    // 如果是文件路径（不包含协议），构建完整的URL
    // 根据文档，图片访问路径为 /picture/{filePath}
    return `/picture/${avatar}`
  }
  
  // 返回默认头像
  return getDefaultAvatar(doctorGender)
}

/**
 * 获取完整的头像URL（使用API）
 * @param {number} doctorId - 医生ID（可选，不传则获取当前登录医生）
 * @returns {Promise<string>} 完整的头像URL
 */
export const getFullAvatarUrl = async (doctorId = null) => {
  try {
    const { getCurrentDoctorAvatar, getDoctorAvatar } = await import('../api/doctor')
    
    let response
    if (doctorId) {
      response = await getDoctorAvatar(doctorId)
    } else {
      response = await getCurrentDoctorAvatar()
    }
    
    if (response.code === 200 && response.data?.avatarUrl) {
      return response.data.avatarUrl
    } else {
      // 如果API返回null或失败，返回默认头像
      return getDefaultAvatar()
    }
  } catch (error) {
    console.error('获取头像URL失败:', error)
    // 出错时返回默认头像
    return getDefaultAvatar()
  }
}

/**
 * 获取默认头像
 * @param {number} gender - 性别 (1: 男, 2: 女)
 * @returns {string} 默认头像URL
 */
const getDefaultAvatar = (gender) => {
  // 使用一个通用的默认头像URL，避免文件不存在的问题
  return ''
}

/**
 * 头像加载失败处理
 * @param {Event} event - 错误事件
 * @param {Function} fallback - 失败后的回调函数
 */
export const handleAvatarError = (event, fallback) => {
  if (fallback && typeof fallback === 'function') {
    fallback()
  }
  
  // 设置默认头像，防止循环
  if (event.target && event.target.src !== '/default-avatar.png') {
    event.target.src = '/default-avatar.png'
  }
}

/**
 * 验证头像文件
 * @param {File} file - 文件对象
 * @returns {boolean} 是否有效
 */
export const validateAvatarFile = (file) => {
  // 验证文件类型
  const validTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/bmp']
  if (!validTypes.includes(file.type)) {
    return false
  }
  
  // 验证文件大小 (5MB)
  const maxSize = 5 * 1024 * 1024
  if (file.size > maxSize) {
    return false
  }
  
  return true
}

/**
 * 创建头像预览
 * @param {File} file - 文件对象
 * @returns {Promise<string>} Base64预览数据
 */
export const createAvatarPreview = (file) => {
  return new Promise((resolve, reject) => {
    const reader = new FileReader()
    
    reader.onload = (e) => {
      resolve(e.target.result)
    }
    
    reader.onerror = () => {
      reject(new Error('文件读取失败'))
    }
    
    reader.readAsDataURL(file)
  })
}

/**
 * 将Base64转换为文件对象
 * @param {string} base64Data - Base64数据
 * @param {string} filename - 文件名
 * @returns {File} 文件对象
 */
export const base64ToFile = (base64Data, filename) => {
  // 从Base64数据中提取MIME类型
  const matches = base64Data.match(/^data:([^;]+);base64,(.+)$/)
  
  if (!matches) {
    throw new Error('无效的Base64数据')
  }
  
  const mimeType = matches[1]
  const base64String = matches[2]
  
  // 使用更兼容的方法转换Base64
  let byteCharacters
  try {
    // 尝试使用全局的atob函数
    if (typeof atob !== 'undefined') {
      byteCharacters = atob(base64String)
    } else {
      // 如果没有atob，使用Buffer（Node.js环境）
      byteCharacters = Buffer.from(base64String, 'base64').toString('binary')
    }
  } catch (error) {
    // 如果都失败了，使用简单的字符串转换
    byteCharacters = decodeURIComponent(escape(base64String))
  }
  
  const byteNumbers = new Array(byteCharacters.length)
  
  for (let i = 0; i < byteCharacters.length; i++) {
    byteNumbers[i] = byteCharacters.charCodeAt(i)
  }
  
  const byteArray = new Uint8Array(byteNumbers)
  const blob = new Blob([byteArray], { type: mimeType })
  
  // 转换为File对象
  return new File([blob], filename, { type: mimeType })
}
